/**
 * 用户状态管理
 * 使用Pinia管理用户登录状态和个人信息
 */
import { defineStore } from 'pinia';
import api from '@/api/index.js';

// 定义用户状态store
export const useUserStore = defineStore('user', {
  // 状态数据
  state: () => ({
    // 用户信息
    userInfo: uni.getStorageSync('userInfo') ? JSON.parse(uni.getStorageSync('userInfo')) : null,
    // JWT令牌
    token: uni.getStorageSync('token') || '',
    // 登录状态
    isLoggedIn: !!uni.getStorageSync('token'),
    // 错误信息
    error: null
  }),
  
  // 计算属性
  getters: {
    // 获取用户ID
    userId: (state) => state.userInfo ? state.userInfo.id : null,
    // 获取用户名
    username: (state) => state.userInfo ? state.userInfo.username : '',
    // 获取用户头像
    avatar: (state) => state.userInfo ? state.userInfo.avatar : '',
    // 判断是否已登录
    loggedIn: (state) => state.isLoggedIn
  },
  
  // 操作方法
  actions: {
    /**
     * 用户登录
     * @param {Object} loginData 登录数据
     * @returns {Promise} 登录结果Promise
     */
    /**
     * 用户登录方法 - 增强版
     * 实现可靠的状态更新和事件通知
     * @param {Object} loginData 登录数据
     * @returns {Promise} 登录结果Promise
     */
    async login(loginData) {
      // 先重置状态，避免漏洞
      this.isLoggedIn = false;
      this.error = '';
      
      try {
        console.log('开始登录请求:', loginData.username);
        
        // 调用登录接口
        const res = await api.auth.login({
          account: loginData.username, // 将username改为account以匹配后端要求
          password: loginData.password
        });
        
        if (!res || !res.data) {
          throw new Error('登录失败，服务器响应不完整');
        }
        
        console.log('登录成功，获取到数据:', res.data);
        
        // 步骤1: 先存储JWT令牌，后续操作需要用到认证
        if (res.data.token) {
          this.setToken(res.data.token);
          console.log('令牌已存储');
        } else {
          console.warn('响应中没有发现令牌');
        }
        
        // 步骤2: 保存基本用户信息
        if (res.data.userInfo) {
          this.setUserInfo(res.data.userInfo);
        } else {
          this.setUserInfo(res.data); // 兼容直接返回用户数据的情况
        }
        
        // 步骤3: 明确标记为已登录状态 (内存 + 本地存储)
        this.isLoggedIn = true;
        
        // 使用多种方式保存登录状态，增强可靠性
        uni.setStorageSync('isLoggedIn', 'true');
        uni.setStorageSync('loginTimestamp', Date.now());
        
        // 步骤4: 获取最新完整用户信息（可能包含登录响应中没有的字段）
        try {
          await this.fetchCurrentUser();
          console.log('已获取用户完整信息');
        } catch (userInfoError) {
          console.warn('获取用户完整信息失败，但登录已成功:', userInfoError);
          // 即使获取完整信息失败，仍然认为登录成功
        }
        
        // 步骤5: 调用三次事件通知机制，确保所有页面都能接收到通知
        // 第1次通知 - 立即触发
        uni.$emit('loginStateChanged', { loggedIn: true, userInfo: this.userInfo });
        
        // 第2次通知 - 延迟300ms，确保事件已被所有页面注册
        setTimeout(() => {
          uni.$emit('loginStateChanged', { loggedIn: true, userInfo: this.userInfo });
          console.log('发送第2次登录状态通知');
        }, 300);
        
        // 第3次通知 - 延迟600ms，再次确认状态已同步
        setTimeout(() => {
          if (this.isLoggedIn) {
            uni.$emit('loginStateChanged', { loggedIn: true, userInfo: this.userInfo });
            console.log('发送第3次登录状态通知');
            
            // 同时触发全局数据刷新事件
            uni.$emit('refreshPageData');
          }
        }, 600);
        
        return Promise.resolve({ ...res.data, success: true });
      } catch (error) {
        console.error('登录失败:', error);
        this.error = error.message || '登录失败';
        this.isLoggedIn = false;
        uni.setStorageSync('isLoggedIn', 'false');
        return Promise.reject(error);
      }
    },
    
    /**
     * 用户注册 - 增强版
     * @param {Object} registerData 注册数据
     * @returns {Promise} 注册结果Promise
     */
    async register(registerData) {
      try {
        console.log('开始注册请求:', registerData.username);
        
        // 构造符合后端要求的注册数据格式
        const registerRequest = {
          username: registerData.username,
          password: registerData.password,
          confirmPassword: registerData.confirmPassword,
          email: registerData.email
        };
        
        // 调用注册接口
        const res = await api.auth.register(registerRequest);
        console.log('注册响应数据:', res);
        
        // 完整处理注册响应
        if (res && res.data) {
          // 直接处理注册返回的token和用户信息，而不是再次登录
          if (res.data.token) {
            // 添加日志跟踪
            console.log('注册成功，收到token:', res.data.token.substring(0, 15) + '...');
            
            // 设置令牌
            this.setToken(res.data.token);
            
            // 设置用户信息
            if (res.data.user || res.data.userInfo) {
              const userInfo = res.data.user || res.data.userInfo;
              this.setUserInfo(userInfo);
            } else {
              // 如果没有返回用户信息，可以构造一个基本的
              this.setUserInfo({
                username: registerData.username,
                email: registerData.email
              });
            }
            
            // 设置登录状态
            this.isLoggedIn = true;
            uni.setStorageSync('isLoggedIn', 'true');
            
            // 发送登录状态变化事件
            uni.$emit('loginStateChanged', { loggedIn: true, userInfo: this.userInfo });
            
            // 同时用第二种方式保存token，增加兼容性
            uni.setStorageSync('Authorization', `Bearer ${res.data.token}`);
            
            // 尝试获取完整用户信息
            try {
              await this.fetchCurrentUser();
              console.log('注册后获取到完整用户数据');
            } catch (userError) {
              console.warn('获取用户完整数据失败，但不影响注册结果:', userError);
            }
          } else {
            console.warn('注册成功，但响应中没有token，尝试登录');
            // 如果没有直接返回token，尝试登录
            try {
              await this.login({
                username: registerData.username,
                password: registerData.password
              });
              console.log('注册后自动登录成功');
            } catch (loginError) {
              console.error('注册后自动登录失败:', loginError);
              // 登录失败不影响注册结果
            }
          }
          
          return Promise.resolve(res);
        } else {
          throw new Error('注册失败，返回数据格式不正确');
        }
      } catch (error) {
        console.error('注册请求失败:', error);
        this.error = error.message || '注册失败';
        return Promise.reject(error);
      }
    },
    
    /**
     * 退出登录
     */
    async logout() {
      console.log('开始执行退出登录操作');
      
      try {
        // 尝试调用后端退出登录接口（如果有的话）
        if (api.auth.logout) {
          try {
            await api.auth.logout();
            console.log('后端退出接口调用成功');
          } catch (e) {
            console.warn('后端退出接口调用失败，继续本地清理:', e);
          }
        }
      } catch (error) {
        console.warn('尝试调用退出 API 时出错，继续本地清理:', error);
      } finally {
        // 清除用户信息
        this.clearUserInfo();
        // 清除JWT令牌
        this.clearToken();
        
        // 清除登录状态
        this.isLoggedIn = false;
        uni.removeStorageSync('isLoggedIn');
        
        // 清除可能存在的其他登录相关数据
        uni.removeStorageSync('refreshToken');
        uni.removeStorageSync('tokenExpires');
        
        // 触发全局事件通知其他页面登录状态变化
        uni.$emit('loginStateChanged', { loggedIn: false });
        
        // 重置应用状态
        // 可以在这里调用其他 store 的重置方法，例如图书收藏列表等
        
        console.log('用户已成功退出登录，所有状态已清除');
        
        // 跳转到登录页
        uni.reLaunch({
          url: '/pages/login/login'
        });
      }
    },
    
    /**
     * 检查用户名是否已存在
     * @param {String} username 用户名
     * @returns {Promise<Boolean>} 是否存在
     */
    async checkUsername(username) {
      try {
        const res = await api.auth.checkUsername(username);
        return res.data;
      } catch (error) {
        this.error = error.message || '检查用户名失败';
        return Promise.reject(error);
      }
    },
    
    /**
     * 检查邮箱是否已存在
     * @param {String} email 邮箱
     * @returns {Promise<Boolean>} 是否存在
     */
    async checkEmail(email) {
      try {
        const res = await api.auth.checkEmail(email);
        return res.data;
      } catch (error) {
        this.error = error.message || '检查邮箱失败';
        return Promise.reject(error);
      }
    },
    
    /**
     * 检查手机号是否已存在
     * @param {String} phone 手机号
     * @returns {Promise<Boolean>} 是否存在
     */
    async checkPhone(phone) {
      try {
        const res = await api.auth.checkPhone(phone);
        return res.data;
      } catch (error) {
        this.error = error.message || '检查手机号失败';
        return Promise.reject(error);
      }
    },
    
    /**
     * 获取当前登录用户信息
     * 用于刷新用户数据或检查登录状态
     */
    async fetchCurrentUser() {
      try {
        // 如果没有登录，则不请求
        if (!this.isLoggedIn) return null;
        
        const res = await api.auth.getCurrentUser();
        
        if (res && res.data) {
          // 更新用户信息
          this.setUserInfo(res.data);
          return res.data;
        } else {
          throw new Error('获取用户信息失败');
        }
      } catch (error) {
        // 如果是401错误，则清除登录状态
        if (error.statusCode === 401) {
          this.logout();
        }
        
        this.error = error.message || '获取用户信息失败';
        return Promise.reject(error);
      }
    },
    
    /**
     * 保存用户信息
     * @param {Object} userInfo 用户信息
     */
    setUserInfo(userInfo) {
      this.userInfo = userInfo;
      this.isLoggedIn = true;
      // 持久化存储
      uni.setStorageSync('userInfo', JSON.stringify(userInfo));
    },
    
    /**
     * 清除用户信息
     */
    clearUserInfo() {
      this.userInfo = null;
      this.isLoggedIn = false;
      // 清除持久化存储
      uni.removeStorageSync('userInfo');
    },
    
    /**
     * 保存JWT令牌
     * @param {String} token JWT令牌
     */
    setToken(token) {
      this.token = token;
      this.isLoggedIn = true;
      
      // 增加令牌过期时间管理
      const tokenInfo = {
        value: token,
        expires: Date.now() + 24 * 60 * 60 * 1000 // 默认1天过期
      };
      
      // 持久化存储
      uni.setStorageSync('tokenInfo', JSON.stringify(tokenInfo));
      uni.setStorageSync('token', token); // 保留原有存储以保持兼容性
    },
    
    /**
     * 清除JWT令牌
     */
    clearToken() {
      this.token = '';
      this.isLoggedIn = false;
      // 清除持久化存储
      uni.removeStorageSync('token');
      uni.removeStorageSync('tokenInfo');
    },
    
    /**
     * 检查token是否有效
     * 已增加登录页面检查，避免自动跳转
     * @returns {Boolean} token是否有效
     */
    checkTokenValidity() {
      try {
        // 检查是否在登录页面
        const loginPageActive = uni.getStorageSync('loginPageActive');
        const loginPageVisited = uni.getStorageSync('loginPageVisited');
        
        // 如果是登录页面在访问，直接返回true防止检查和跳转
        if (loginPageActive === 'true' || loginPageVisited === 'true') {
          console.log('检测到当前在登录页面，禁止Token检查跳转');
          return true;
        }
        
        // 如果不在登录页面，才获取和验证token
        const token = uni.getStorageSync('token');
        if (token) {
          this.isLoggedIn = true;
          return true;
        } else {
          this.isLoggedIn = false;
          return false;
        }
      } catch (error) {
        console.error('检查登录状态错误:', error);
        this.clearToken();
        return false;
      }
    },
    
    /**
     * 刷新令牌
     * @returns {Promise} 刷新结果Promise
     */
    async refreshToken() {
      try {
        // 调用刷新令牌接口
        const res = await api.auth.refreshToken(this.token);
        
        if (res && res.data && res.data.token) {
          this.setToken(res.data.token);
          return true;
        } else {
          throw new Error('刷新令牌失败');
        }
      } catch (error) {
        this.error = error.message || '刷新令牌失败';
        // 如果刷新失败，需要重新登录
        this.clearToken();
        return false;
      }
    }
  }
});
